// 用户个人资料页面逻辑
const app = getApp();
const tokenManager = require('../../utils/tokenManager');
const storage = require('../../utils/storage.js');

Page({
  data: {
    userInfo: null,
    loading: false,
    editMode: false,
    formData: {
      nickname: '',
      email: '',
      phone: ''
    },
    avatarUrl: '',
    activeTab: 'dynamic',
    showFullIntro: false,
    dynamicList: [], // 动态列表数据
    isFollowing: false, // 是否已关注该用户
    userId: '' // 当前查看的用户ID
  },
  
  onLoad(options) {
    // 检查登录状态
    if (!tokenManager.isLoggedIn()) {
      this.redirectToLogin();
      return;
    }
    
    // 获取传入的用户ID和其他参数
    if (options.userId) {
      this.setData({
        userId: options.userId
      });
      
      // 加载用户信息
      this.loadUserInfo();
      
      // 加载动态数据
      this.loadDynamicData();
      
      // 检查是否已关注该用户
      this.checkFollowStatus();
    } else {
      wx.showToast({
        title: '用户信息不完整',
        icon: 'none'
      });
      setTimeout(() => {
        wx.navigateBack();
      }, 1500);
    }
    
    // 注册页面实例
    app.registerPageInstance(this);
    
    // 注册头像更新事件监听
    app.on('avatarUpdate', this.handleAvatarUpdate, this);
  },
  
  onUnload() {
    // 注销页面实例
    app.unregisterPageInstance(this);
    
    // 注销事件监听
    app.off('avatarUpdate', this.handleAvatarUpdate);
  },
  
  onShow() {
    // 每次页面显示时刷新数据
    if (tokenManager.isLoggedIn()) {
      // 检查是否需要刷新用户信息
      if (app.globalData.needRefreshUserInfo) {
        console.log('检测到需要刷新用户信息');
        app.globalData.needRefreshUserInfo = false;
        this.refreshUserInfo();
      } else {
        this.loadUserInfo();
      }
    }
  },
  
  // 处理头像更新事件
  handleAvatarUpdate: function(avatarUrl) {
    console.log('接收到头像更新事件', avatarUrl);
    
    if (!avatarUrl) return;
    
    // 更新本地头像
    const userInfo = this.data.userInfo || {};
    userInfo.avatarUrl = avatarUrl;
    
    this.setData({
      userInfo: userInfo,
      avatarUrl: avatarUrl
    });
    
    // 强制重新加载图片
    storage.reloadImage(avatarUrl)
      .then(() => {
        console.log('头像更新成功');
      })
      .catch(err => {
        console.error('头像更新失败', err);
      });
  },
  
  // 刷新用户信息
  refreshUserInfo: function() {
    console.log('从本地存储刷新用户信息');
    
    // 从Storage获取最新用户信息
    const userInfo = wx.getStorageSync('userInfo') || {};
    console.log('本地存储中的用户信息:', userInfo);
    
    // 处理字段名差异
    let displayUserInfo = {
      ...userInfo,
      // 确保avatar字段存在（优先使用avatarUrl，如果没有则使用avatar）
      avatar: userInfo.avatarUrl || userInfo.avatar,
      // 确保avatarUrl字段存在（优先使用avatarUrl，如果没有则使用avatar）
      avatarUrl: userInfo.avatarUrl || userInfo.avatar,
      // 确保nickname字段存在（优先使用nickname，如果没有则使用nickName）
      nickname: userInfo.nickname || userInfo.nickName,
      // 确保nickName字段存在（优先使用nickName，如果没有则使用nickname）
      nickName: userInfo.nickName || userInfo.nickname
    };
    
    // 如果有头像URL，强制添加时间戳防止缓存
    if (displayUserInfo.avatarUrl) {
      const timestamp = Date.now();
      let avatarUrl = displayUserInfo.avatarUrl;
      
      // 检查URL是否已经有时间戳参数
      if (avatarUrl.indexOf('t=') === -1) {
        avatarUrl = avatarUrl.includes('?') 
          ? `${avatarUrl}&t=${timestamp}` 
          : `${avatarUrl}?t=${timestamp}`;
      }
      
      displayUserInfo.avatarUrl = avatarUrl;
      displayUserInfo.avatar = avatarUrl; // 同时更新两个字段
      
      // 强制重新加载图片
      storage.reloadImage(avatarUrl)
        .then(() => {
          console.log('头像刷新成功');
        })
        .catch(err => {
          console.error('头像刷新失败', err);
        });
    }
    
    console.log('处理后的显示用户信息:', displayUserInfo);
    
    // 更新页面数据
    this.setData({
      userInfo: displayUserInfo,
      avatarUrl: displayUserInfo.avatarUrl || displayUserInfo.avatar,
      formData: {
        nickname: displayUserInfo.nickname || displayUserInfo.nickName || '',
        email: displayUserInfo.email || '',
        phone: displayUserInfo.phone || ''
      }
    });
    
    // 加载动态数据
    this.loadDynamicData();
  },
  
  /**
   * 加载用户信息
   */
  async loadUserInfo() {
    this.setData({ loading: true });
    
    try {
      // 先尝试从本地存储获取基本信息作为备份
      const localUserInfo = wx.getStorageSync('userInfo') || {};
      
      // 尝试从API获取信息
      const token = tokenManager.getAccessToken();
      const apiUserInfo = await app.api.user.getProfile(token);
      
      // 如果API成功返回，使用API数据
      if (apiUserInfo) {
        // 添加时间戳到头像URL防止缓存
        if (apiUserInfo.avatar) {
          const timestamp = Date.now();
          apiUserInfo.avatar = apiUserInfo.avatar.includes('?') 
            ? `${apiUserInfo.avatar}&t=${timestamp}` 
            : `${apiUserInfo.avatar}?t=${timestamp}`;
        }
        
        // 将API数据中的avatar映射到avatarUrl (如果需要)
        apiUserInfo.avatarUrl = apiUserInfo.avatarUrl || apiUserInfo.avatar;
        
        this.setData({
          userInfo: apiUserInfo,
          avatarUrl: apiUserInfo.avatar || apiUserInfo.avatarUrl,
          formData: {
            nickname: apiUserInfo.nickname || '',
            email: apiUserInfo.email || '',
            phone: apiUserInfo.phone || ''
          },
          loading: false
        });
      } else {
        // 如果API没有返回数据，使用本地数据
        throw new Error('API返回数据为空');
      }
      
      // 加载用户动态数据
      this.loadDynamicData();
    } catch (error) {
      console.error('获取用户信息失败', error);
      this.setData({ loading: false });
      
      // 从本地存储获取
      this.refreshUserInfo();
      
      wx.showToast({
        title: '获取API信息失败，使用本地数据',
        icon: 'none'
      });
    }
  },
  
  // 加载动态数据
  loadDynamicData() {
    // 模拟从服务器获取该用户的动态数据
    const dynamicList = [
      {
        id: 'dynamic001',
        title: '技术分享：小程序开发心得',
        content: '今天给大家分享一下小程序开发的一些经验和技巧，希望对大家有所帮助。首先，我们需要了解小程序的基本架构...',
        views: 1024,
        time: '2023-03-26'
      },
      {
        id: 'dynamic002',
        title: '参加了校园编程大赛',
        content: '昨天参加了学校举办的编程大赛，虽然没有获得冠军，但收获了很多经验和友谊，感谢一路上支持我的朋友们！',
        views: 567,
        time: '2023-03-25'
      },
      {
        id: 'dynamic003',
        title: '分享一个有趣的项目',
        content: '最近在做一个基于人工智能的小游戏，使用了一些有趣的算法和设计理念，希望大家能给我一些建议和反馈。',
        views: 832,
        time: '2023-03-24'
      }
    ];
    
    this.setData({ dynamicList });
  },
  
  // 检查是否已关注该用户
  checkFollowStatus() {
    // 此处应该调用后端API检查是否已关注
    // 模拟随机关注状态
    const isFollowing = Math.random() > 0.5;
    this.setData({ isFollowing });
  },
  
  // 切换关注状态
  toggleFollow() {
    const isFollowing = !this.data.isFollowing;
    
    // 此处应该调用后端API更新关注状态
    this.setData({ isFollowing });
    
    wx.showToast({
      title: isFollowing ? '已关注' : '已取消关注',
      icon: 'success'
    });
    
    // 更新粉丝数
    let fans = parseInt(this.data.userInfo.fans);
    fans = isFollowing ? fans + 1 : Math.max(0, fans - 1);
    
    this.setData({
      'userInfo.fans': fans.toString()
    });
  },
  
  // 发送消息
  sendMessage() {
    const { userId, userInfo } = this.data;
    
    wx.navigateTo({
      url: `/pages/chat/chat?id=${userId}&name=${encodeURIComponent(userInfo.nickName)}&avatar=${encodeURIComponent(userInfo.avatarUrl)}&type=personal`,
      success: function() {
        console.log('跳转到聊天页面成功');
      },
      fail: function(err) {
        console.error('跳转到聊天页面失败:', err);
        wx.showToast({
          title: '无法打开聊天',
          icon: 'none'
        });
      }
    });
  },
  
  // 返回上一页
  navigateBack() {
    wx.navigateBack();
  },
  
  // 切换标签页
  switchTab(e) {
    const tab = e.currentTarget.dataset.tab;
    this.setData({
      activeTab: tab
    });
    
    // 根据不同标签加载不同数据
    if (tab === 'dynamic' && this.data.dynamicList.length === 0) {
      this.loadDynamicData();
    }
  },
  
  // 显示简介
  toggleIntro() {
    wx.showModal({
      title: '个人简介',
      content: this.data.userInfo.introduction || '该用户很懒，还没有填写简介',
      showCancel: false,
      confirmText: '确定'
    });
  },
  
  // 导航到关注列表
  navigateToFollows() {
    wx.navigateTo({
      url: `/pages/user-list/user-list?type=follow&userId=${this.data.userId}&userName=${encodeURIComponent(this.data.userInfo.nickName)}`
    });
  },
  
  // 导航到粉丝列表
  navigateToFans() {
    wx.navigateTo({
      url: `/pages/user-list/user-list?type=fan&userId=${this.data.userId}&userName=${encodeURIComponent(this.data.userInfo.nickName)}`
    });
  },
  
  // 导航到被喜欢列表
  navigateToLikes() {
    wx.navigateTo({
      url: `/pages/user-list/user-list?type=like&userId=${this.data.userId}&userName=${encodeURIComponent(this.data.userInfo.nickName)}`
    });
  },
  
  // 导航到好友列表
  navigateToFriends() {
    wx.navigateTo({
      url: `/pages/user-list/user-list?type=friend&userId=${this.data.userId}&userName=${encodeURIComponent(this.data.userInfo.nickName)}`
    });
  },
  
  // 导航到动态详情
  navigateToDetail(e) {
    const dynamicId = e.currentTarget.dataset.id;
    wx.navigateTo({
      url: `/pages/dynamic-detail/dynamic-detail?id=${dynamicId}&userId=${this.data.userId}`
    });
  },
  
  // 收藏操作
  handleCollect(e) {
    const index = e.currentTarget.dataset.index;
    wx.showToast({
      title: '已收藏',
      icon: 'success'
    });
  },
  
  // 分享操作
  handleShare(e) {
    const index = e.currentTarget.dataset.index;
    wx.showShareMenu({
      withShareTicket: true,
      menus: ['shareAppMessage', 'shareTimeline']
    });
  },
  
  // 评论操作
  handleComment(e) {
    const index = e.currentTarget.dataset.index;
    const dynamicId = this.data.dynamicList[index].id;
    wx.navigateTo({
      url: `/pages/dynamic-detail/dynamic-detail?id=${dynamicId}&showComment=true&userId=${this.data.userId}`
    });
  },
  
  // 围观操作
  handleWatch(e) {
    const index = e.currentTarget.dataset.index;
    wx.showToast({
      title: '已围观',
      icon: 'success'
    });
  },
  
  // 分享到朋友圈
  onShareTimeline() {
    return {
      title: `${this.data.userInfo.nickName}的个人主页`,
      query: `userId=${this.data.userId}`
    };
  },
  
  // 分享给朋友
  onShareAppMessage() {
    return {
      title: `${this.data.userInfo.nickName}的个人主页`,
      path: `/pages/user-profile/user-profile?userId=${this.data.userId}&userName=${encodeURIComponent(this.data.userInfo.nickName)}&userAvatar=${encodeURIComponent(this.data.userInfo.avatarUrl)}`,
      imageUrl: this.data.userInfo.avatarUrl
    };
  },
  
  /**
   * 处理用户输入变化
   */
  onInputChange(e) {
    const field = e.currentTarget.dataset.field;
    const value = e.detail.value;
    
    this.setData({
      [`formData.${field}`]: value
    });
  },
  
  /**
   * 处理获取手机号
   */
  getPhoneNumber(e) {
    if (e.detail.errMsg === 'getPhoneNumber:ok') {
      // 如果用户同意授权手机号
      wx.showToast({
        title: '已获取手机号',
        icon: 'success'
      });
      
      // 实际应用中，需要将cloudID发送到服务器解析
      // 此处仅作为示例，实际情况需要在服务端解析
      console.log('手机号cloudID:', e.detail.cloudID);
    } else {
      wx.showToast({
        title: '未授权手机号',
        icon: 'none'
      });
    }
  },
  
  /**
   * 切换编辑模式
   */
  toggleEditMode() {
    const { editMode, userInfo } = this.data;
    
    if (editMode) {
      // 退出编辑模式，重置表单数据
      this.setData({
        editMode: false,
        formData: {
          nickname: userInfo.nickname || '',
          email: userInfo.email || '',
          phone: userInfo.phone || ''
        }
      });
    } else {
      // 进入编辑模式
      this.setData({
        editMode: true
      });
    }
  },
  
  /**
   * 保存用户信息
   */
  async saveUserInfo() {
    const { formData } = this.data;
    
    // 表单验证
    let isValid = true;
    let errorMsg = '';
    
    // 昵称验证 - 必填且长度在2-20之间
    if (!formData.nickname || formData.nickname.trim() === '') {
      isValid = false;
      errorMsg = '昵称不能为空';
    } else if (formData.nickname.length < 2 || formData.nickname.length > 20) {
      isValid = false;
      errorMsg = '昵称长度应在2-20个字符之间';
    }
    
    // 邮箱验证 - 如果填写了则必须格式正确
    if (formData.email && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(formData.email)) {
      isValid = false;
      errorMsg = '邮箱格式不正确';
    }
    
    // 手机验证 - 如果填写了则必须符合中国大陆手机号规则
    if (formData.phone && !/^1[3-9]\d{9}$/.test(formData.phone)) {
      isValid = false;
      errorMsg = '手机号格式不正确';
    }
    
    // 如果验证失败，显示错误提示并返回
    if (!isValid) {
      wx.showToast({
        title: errorMsg,
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    // 显示加载状态
    this.setData({ loading: true });
    wx.showLoading({
      title: '保存中...',
      mask: true
    });
    
    try {
      console.log('准备更新用户资料:', formData);
      const token = tokenManager.getAccessToken();
      
      // 调用API更新用户资料
      const result = await app.api.user.updateProfile(token, formData);
      console.log('更新用户资料成功:', result);
      
      // 隐藏加载提示
      wx.hideLoading();
      
      // 显示成功提示
      wx.showToast({
        title: '保存成功',
        icon: 'success',
        duration: 1500
      });
      
      // 退出编辑模式
      this.setData({
        editMode: false,
        loading: false
      });
      
      // 重新加载用户信息以显示最新数据
      setTimeout(() => {
        this.loadUserInfo();
      }, 1500);
      
    } catch (error) {
      console.error('更新用户信息失败:', error);
      wx.hideLoading();
      this.setData({ loading: false });
      
      // 根据错误码显示不同的错误提示
      if (error.code === 409) {
        wx.showToast({
          title: error.message || '邮箱或手机号已被占用',
          icon: 'none',
          duration: 2000
        });
      } else if (error.code === 400) {
        wx.showToast({
          title: error.message || '提交的数据格式有误',
          icon: 'none',
          duration: 2000
        });
      } else if (error.code === 401) {
        wx.showToast({
          title: '登录已过期，请重新登录',
          icon: 'none',
          duration: 2000
        });
        setTimeout(() => {
          this.redirectToLogin();
        }, 2000);
      } else {
        wx.showToast({
          title: error.message || '保存失败，请稍后重试',
          icon: 'none',
          duration: 2000
        });
      }
    }
  },
  
  /**
   * 更换头像
   */
  chooseAvatar() {
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: (res) => {
        const tempFilePath = res.tempFilePaths[0];
        
        // 显示预览
        this.setData({
          avatarUrl: tempFilePath
        });
        
        // 弹出确认框
        wx.showModal({
          title: '更换头像',
          content: '确定要使用这张照片作为新头像吗？',
          confirmText: '确定',
          cancelText: '取消',
          success: (result) => {
            if (result.confirm) {
              this.uploadAvatar(tempFilePath);
            } else {
              // 取消更换，恢复原头像
              this.setData({
                avatarUrl: this.data.userInfo.avatar
              });
            }
          }
        });
      }
    });
  },
  
  /**
   * 上传头像
   */
  async uploadAvatar(filePath) {
    this.setData({ loading: true });
    
    try {
      const token = tokenManager.getAccessToken();
      const result = await app.api.user.updateAvatar(token, filePath);
      
      this.setData({
        avatarUrl: result.avatar,
        loading: false
      });
      
      wx.showToast({
        title: '头像更新成功',
        icon: 'success'
      });
      
      // 重新加载用户信息
      this.loadUserInfo();
    } catch (error) {
      console.error('上传头像失败', error);
      this.setData({ loading: false });
      
      wx.showToast({
        title: '上传头像失败',
        icon: 'none'
      });
    }
  },
  
  /**
   * 退出登录
   */
  logout() {
    wx.showModal({
      title: '提示',
      content: '确定要退出登录吗？',
      success: (res) => {
        if (res.confirm) {
          app.logout();
        }
      }
    });
  },
  
  /**
   * 跳转到登录页
   */
  redirectToLogin() {
    wx.redirectTo({
      url: '/pages/login/login'
    });
  }
}); 